// ==UserScript==
// @name         预警插件-增强版
// @namespace    http://tampermonkey.net/
// @version      0.4
// @description  增强版预警插件，支持浏览器最小化提醒、突破静音、多种提醒方式
// @author       You
// @match        http://10.4.192.46:8080/PIIAP/DataGather/StabilityClues/StabSupervision/list.jsp
// @grant        GM_notification
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_addStyle
// @grant        unsafeWindow
// @require      https://code.jquery.com/jquery-3.6.0.min.js
// ==/UserScript==

(function () {
  'use strict';

  // 全局变量
  let lastAlertTime = 0;
  let alertCount = 0;
  let isAlerting = false;
  let audioContext = null;
  let oscillator = null;
  let gainNode = null;
  let unitPhoneMap = {}; // 存储单位-电话号码映射

  // 直接加载硬编码的单位电话号码映射
  function loadUnitPhoneMap () {
    unitPhoneMap = {
      随州南站派出所: '015-86947',
      枣阳站派出所: '015-84110',
      襄阳东站派出所: '015-47110',
      谷城北站派出所: '015-86937',
      丹江口站派出所: '015-86955',
      武当山西站派出所: '015-86958',
      十堰东站派出所: '015-86110',
      十堰站派出所: '015-78110',
      随州站派出所: '015-81110',
      陈家湖站派出所: '015-86978',
      襄阳北站派出所: '015-42110',
      襄州站派出所: '015-86769',
      襄阳站派出所: '015-25110',
      宜城站派出所: '015-56110',
      荆门站派出所: '015-52110',
      当阳站派出所: '015-59110',
      宜昌站派出所: '015-55278',
      松滋站派出所: '015-59628',
      应城站派出所: '015-50266',
      京山站派出所: '015-50218',
      钟祥站派出所: '015-51110',
      天门南站派出所: '051-77068',
      潜江站派出所: '051-77088',
      荆州站派出所: '015-61108',
      枝江北站派出所: '015-61158',
      宜昌东站派出所: '015-61558',
      建始站派出所: '015-62558',
      恩施站派出所: '015-62110',
      利川站派出所: '015-62838',
      南漳站派出所: '015-47528',
      保康县站派出所: '015-47558',
      兴山站派出所: '015-47541',
      乘警支队: '015-20110',
    };
    console.log('已加载单位电话号码映射:', Object.keys(unitPhoneMap).length, '个单位');

    // 显示调试信息，帮助用户了解映射表内容
    debugUnitMatching();

    // 启动持续监控电话号码显示
    startPhoneDisplayMonitor();
  }

  // 调试单位匹配
  function debugUnitMatching () {
    console.log('🔍 === 单位匹配调试 ===');
    console.log('📞 映射表中的所有单位:');
    Object.keys(unitPhoneMap).forEach((key, index) => {
      console.log(`  ${index + 1}. "${key}" -> "${unitPhoneMap[key]}"`);
    });
    console.log('🔍 === 调试结束 ===');
  }

  // 智能匹配单位名称
  function findBestMatch (unitName) {
    if (!unitName) return null;

    // 直接匹配
    if (unitPhoneMap[unitName]) {
      return unitName;
    }

    // 清理单位名称
    const cleanName = unitName.trim();
    console.log(`🔍 尝试匹配单位名称: "${cleanName}"`);

    // 处理"武汉铁路公安局襄阳公安处xx车站派出所"格式
    let extractedStation = null;

    // 匹配完整格式
    const fullMatch = cleanName.match(/武汉铁路公安局襄阳公安处(.+?)车站派出所/);
    if (fullMatch) {
      extractedStation = fullMatch[1].trim();
      console.log(`📍 从完整格式提取站名: "${extractedStation}"`);
    }

    // 如果没找到完整格式，尝试匹配部分格式
    if (!extractedStation) {
      const partialMatch = cleanName.match(/襄阳公安处(.+?)车站派出所/);
      if (partialMatch) {
        extractedStation = partialMatch[1].trim();
        console.log(`📍 从部分格式提取站名: "${extractedStation}"`);
      }
    }

    // 如果提取到了站名，尝试匹配
    if (extractedStation) {
      // 直接用提取的站名匹配
      const directMatch = extractedStation + '站派出所';
      if (unitPhoneMap[directMatch]) {
        console.log(`✅ 直接匹配成功: "${directMatch}"`);
        return directMatch;
      }

      // 尝试其他变体
      const variants = [extractedStation + '站派出所', extractedStation + '派出所', extractedStation + '车站派出所'];

      for (const variant of variants) {
        if (unitPhoneMap[variant]) {
          console.log(`✅ 变体匹配成功: "${variant}"`);
          return variant;
        }
      }
    }

    // 遍历映射表进行模糊匹配
    for (const [key, value] of Object.entries(unitPhoneMap)) {
      // 完全匹配
      if (key === cleanName) {
        return key;
      }

      // 包含匹配
      if (key.includes(cleanName) || cleanName.includes(key)) {
        return key;
      }

      // 移除常见后缀再匹配
      const cleanKey = key.replace(/(派出所|站|队|大队|中队|民警|公安民警|铁路民警)$/g, '');
      const cleanUnit = cleanName.replace(/(派出所|站|队|大队|中队|民警|公安民警|铁路民警|车站)$/g, '');

      if (cleanKey === cleanUnit || cleanKey.includes(cleanUnit) || cleanUnit.includes(cleanKey)) {
        return key;
      }
    }

    console.log(`❌ 未找到匹配: "${cleanName}"`);
    return null;
  }

  // 持续监控和更新电话号码显示
  let phoneDisplayInterval = null;

  // 更新表格中处理单位列的显示，添加电话号码
  function updateUnitPhoneDisplay () {
    try {
      const table = document.getElementById('DataTables_Table_0');
      if (!table || !table.rows) {
        console.log('表格未找到或没有行数据');
        return;
      }

      console.log('更新电话号码显示 - 表格行数:', table.rows.length);

      // 遍历所有行，找到处理单位列
      for (let i = 1; i < table.rows.length; i++) {
        // 跳过表头
        const row = table.rows[i];
        if (row.cells && row.cells.length >= 11) {
          // 确保至少有11列
          // 根据框架源代码，处理单位列是第11列（索引为10）
          const unitCell = row.cells[10];
          if (unitCell) {
            const cellText = unitCell.innerText.trim();

            // 检查是否已经更新过电话号码（避免重复更新）
            if (!unitCell.querySelector('.phone-info')) {
              // 使用智能匹配
              const matchedUnit = findBestMatch(cellText);

              if (matchedUnit) {
                const phone = unitPhoneMap[matchedUnit];

                // 保存原始内容
                const originalHTML = unitCell.innerHTML;

                // 更新单元格内容，显示单位名称和电话号码
                const newHTML = `
                                    <div style="font-weight: bold; font-size: 14px;">${cellText}</div>
                                    <div class="phone-info" style="color: #007bff; font-size: 12px; margin-top: 4px; padding: 2px 4px; background: #e3f2fd; border-radius: 3px; display: inline-block;">
                                        📞 ${phone}
                                    </div>
                                `;

                unitCell.innerHTML = newHTML;

                // 添加鼠标悬停提示
                unitCell.title = `${cellText} (${matchedUnit})\n电话: ${phone}`;

                console.log(`✅ 匹配成功: "${cellText}" -> "${matchedUnit}" -> 电话: "${phone}"`);
              } else {
                console.log(`❌ 未找到匹配: "${cellText}"`);
              }
            }
          }
        }
      }
    } catch (error) {
      console.log('更新处理单位列显示失败:', error);
      console.error('详细错误:', error);
    }
  }

  // 启动持续监控
  function startPhoneDisplayMonitor () {
    if (phoneDisplayInterval) {
      clearInterval(phoneDisplayInterval);
    }

    // 每2秒检查一次并更新电话号码显示
    phoneDisplayInterval = setInterval(() => {
      updateUnitPhoneDisplay();
    }, 2000);

    console.log('已启动电话号码显示监控');
  }

  // 停止监控
  function stopPhoneDisplayMonitor () {
    if (phoneDisplayInterval) {
      clearInterval(phoneDisplayInterval);
      phoneDisplayInterval = null;
      console.log('已停止电话号码显示监控');
    }
  }

  // 等待页面和jQuery完全加载
  function waitForJQuery (callback) {
    if (typeof jQuery !== 'undefined') {
      callback();
    } else {
      setTimeout(function () {
        waitForJQuery(callback);
      }, 100);
    }
  }

  // 等待DataTables加载完成
  function waitForDataTable (callback) {
    const table = document.getElementById('DataTables_Table_0');
    if (table && table.rows && table.rows.length > 1) {
      callback();
    } else {
      setTimeout(function () {
        waitForDataTable(callback);
      }, 500);
    }
  }

  // 初始化音频上下文（突破静音限制）
  function initAudioContext () {
    try {
      if (!audioContext) {
        console.log('正在初始化音频上下文...');
        audioContext = new (window.AudioContext || window.webkitAudioContext)();

        if (!audioContext) {
          throw new Error('浏览器不支持Web Audio API');
        }

        gainNode = audioContext.createGain();
        oscillator = audioContext.createOscillator();

        oscillator.connect(gainNode);
        gainNode.connect(audioContext.destination);

        oscillator.frequency.setValueAtTime(800, audioContext.currentTime);
        oscillator.type = 'sine';
        gainNode.gain.setValueAtTime(0.5, audioContext.currentTime);

        console.log('音频上下文初始化成功');
      }
    } catch (error) {
      console.error('音频上下文初始化失败:', error);
      // 尝试降级处理
      if (error.name === 'NotSupportedError') {
        console.warn('当前浏览器不支持Web Audio API，将使用HTML5 Audio作为替代方案');
      }
    }
  }

  // 播放突破静音的警报声
  function playAlertSound () {
    let success = false;

    try {
      console.log('尝试播放警报声...');

      // 方法1: 使用Web Audio API突破静音
      if (audioContext && oscillator && gainNode) {
        console.log('使用Web Audio API播放警报声');

        // 确保音频上下文处于运行状态
        if (audioContext.state === 'suspended') {
          audioContext.resume().then(() => {
            console.log('音频上下文已恢复');
          });
        }

        oscillator.start();
        gainNode.gain.setValueAtTime(0.8, audioContext.currentTime);

        // 创建警报音效
        const now = audioContext.currentTime;
        oscillator.frequency.setValueAtTime(800, now);
        oscillator.frequency.setValueAtTime(1200, now + 0.1);
        oscillator.frequency.setValueAtTime(800, now + 0.2);
        oscillator.frequency.setValueAtTime(1200, now + 0.3);

        setTimeout(() => {
          try {
            if (oscillator) {
              oscillator.stop();
              oscillator = audioContext.createOscillator();
              oscillator.connect(gainNode);
              oscillator.frequency.setValueAtTime(800, audioContext.currentTime);
              oscillator.type = 'sine';
            }
            console.log('Web Audio API警报声播放完成');
          } catch (e) {
            console.error('停止音频时出错:', e);
          }
        }, 400);

        success = true;
      }

      // 方法2: 使用HTML5 Audio作为备用（使用浏览器内置音频）
      const audio = document.getElementById('voice');
      if (audio) {
        console.log('使用HTML5 Audio播放警报声');
        audio.volume = 1.0;
        audio
          .play()
          .then(() => {
            console.log('HTML5音频播放成功');
          })
          .catch((e) => {
            console.error('HTML5音频播放失败:', e);
          });
        success = true;
      }

      // 方法3: 创建临时音频元素
      if (!success) {
        console.log('创建临时音频元素播放警报声');
        const tempAudio = new Audio(
          'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
        );
        tempAudio.volume = 0.8;
        tempAudio
          .play()
          .then(() => {
            console.log('临时音频播放成功');
          })
          .catch((e) => {
            console.error('临时音频播放失败:', e);
          });
        success = true;
      }

      if (!success) {
        console.warn('所有音频播放方法都失败了');
      }
    } catch (error) {
      console.error('音频播放过程中出错:', error);
      // 尝试使用系统通知作为最后的备选方案
      if ('vibrate' in navigator) {
        navigator.vibrate([200, 100, 200]);
        console.log('使用设备震动作为替代提醒');
      }
    }
  }

  // 创建桌面通知
  function showDesktopNotification (title, message) {
    try {
      console.log('尝试创建桌面通知:', title);
      console.log('当前通知权限状态:', Notification.permission);

      // 检查浏览器是否支持通知
      if (!('Notification' in window)) {
        console.warn('当前浏览器不支持桌面通知');
        return;
      }

      // 检测是否为HTTP网站
      const isHTTP = location.protocol === 'http:';
      if (isHTTP) {
        console.warn('⚠️ HTTP网站无法使用通知API，这是浏览器安全限制');
        console.log('💡 解决方法：');
        console.log('  1. 联系系统管理员升级网站到HTTPS');
        console.log('  2. 使用Chrome命令行参数（见控制台说明）');
        console.log('  3. 使用页面内弹窗提醒（已启用）');
        console.log('  4. 安装浏览器扩展绕过限制');

        // 显示详细的命令行设置说明
        console.log('🔧 Chrome命令行参数设置方法：');
        console.log('  1. 右键Chrome快捷方式 → 属性');
        console.log('  2. 在"目标"后面添加参数：');
        console.log('     --disable-web-security --disable-features=VizDisplayCompositor --enable-notifications');
        console.log('  3. 示例：');
        console.log(
          '     "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe" --disable-web-security --disable-features=VizDisplayCompositor --enable-notifications'
        );

        // 直接使用备选方案
        showFallbackNotification(title, message);
        return;
      }

      // 直接尝试请求权限并创建通知
      Notification.requestPermission()
        .then((permission) => {
          console.log('权限请求结果:', permission);
          if (permission === 'granted') {
            console.log('获得桌面通知权限，创建通知');
            createNotification(title, message);
          } else {
            console.warn('用户拒绝了桌面通知权限，使用备选方案');
            showFallbackNotification(title, message);
          }
        })
        .catch((error) => {
          console.error('请求通知权限时出错:', error);
          showFallbackNotification(title, message);
        });
    } catch (error) {
      console.error('桌面通知创建失败:', error);
      // 备选方案：创建页面内通知
      showFallbackNotification(title, message);
    }
  }

  // 创建通知的辅助函数
  function createNotification (title, message) {
    try {
      const notification = new Notification(title, {
        body: message,
        icon: '',
        badge:
          '',
        tag: 'alert-notification',
        requireInteraction: true,
        silent: false,
      });

      // 5秒后自动关闭通知
      setTimeout(() => {
        notification.close();
      }, 5000);

      console.log('桌面通知创建成功');
    } catch (error) {
      console.error('创建通知失败:', error);
      throw error; // 重新抛出错误，让调用者处理
    }
  }

  // 备选通知方案（当桌面通知不可用时）
  function showFallbackNotification (title, message) {
    try {
      console.log('使用备选通知方案');

      // 创建页面内通知
      const notification = document.createElement('div');
      notification.id = 'fallback-notification';
      notification.style.cssText = `
                position: fixed;
                top: 20px;
                right: 20px;
                background: #ff4444;
                color: white;
                padding: 15px 20px;
                border-radius: 8px;
                box-shadow: 0 4px 12px rgba(0,0,0,0.3);
                z-index: 10000;
                max-width: 300px;
                font-weight: bold;
                animation: slideIn 0.5s ease-out;
            `;

      notification.innerHTML = `
                <div style="font-size: 16px; margin-bottom: 5px;">${title}</div>
                <div style="font-size: 14px; opacity: 0.9;">${message}</div>
                <button onclick="this.parentNode.remove()" style="
                    position: absolute;
                    top: 5px;
                    right: 5px;
                    background: none;
                    border: none;
                    color: white;
                    font-size: 18px;
                    cursor: pointer;
                ">×</button>
            `;

      document.body.appendChild(notification);

      // 添加CSS动画
      const style = document.createElement('style');
      style.textContent = `
                @keyframes slideIn {
                    from { transform: translateX(100%); opacity: 0; }
                    to { transform: translateX(0); opacity: 1; }
                }
            `;
      document.head.appendChild(style);

      // 5秒后自动移除
      setTimeout(() => {
        if (notification.parentNode) {
          notification.remove();
        }
      }, 5000);

      console.log('备选通知创建成功');
    } catch (error) {
      console.error('备选通知创建失败:', error);
    }
  }

  // 创建弹窗提醒（终极版）
  function showAlertDialog () {
    try {
      // 如果已有弹窗，先移除
      const existingModal = document.getElementById('alertModal');
      if (existingModal) {
        document.body.removeChild(existingModal);
      }

      // 创建全屏遮罩
      const modal = document.createElement('div');
      modal.id = 'alertModal';
      modal.style.cssText = `
                position: fixed;
                top: 0;
                left: 0;
                width: 100vw;
                height: 100vh;
                background: rgba(255, 0, 0, 0.98);
                z-index: 2147483647;
                display: flex;
                align-items: center;
                justify-content: center;
                font-family: Arial, sans-serif;
                backdrop-filter: blur(10px);
                animation: screenPulse 0.5s infinite alternate;
            `;

      const content = document.createElement('div');
      content.style.cssText = `
                background: linear-gradient(135deg, #ff4444 0%, #ff0000 50%, #cc0000 100%);
                color: white;
                padding: 60px;
                border-radius: 30px;
                text-align: center;
                max-width: 700px;
                min-height: 400px;
                box-shadow: 0 30px 80px rgba(255,0,0,0.8);
                animation: emergencyAlert 0.3s infinite alternate;
                border: 6px solid #fff;
                position: relative;
                overflow: hidden;
            `;

      // 添加多层闪烁背景
      content.innerHTML = `
                <div style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: repeating-linear-gradient(45deg, transparent, transparent 15px, rgba(255,255,255,0.2) 15px, rgba(255,255,255,0.2) 30px); animation: backgroundFlash 0.2s infinite;"></div>
                <div style="position: absolute; top: 0; left: 0; right: 0; bottom: 0; background: repeating-linear-gradient(-45deg, transparent, transparent 20px, rgba(255,255,255,0.1) 20px, rgba(255,255,255,0.1) 40px); animation: backgroundFlash 0.3s infinite reverse;"></div>
                <h1 style="font-size: 60px; margin: 0 0 25px 0; text-shadow: 4px 4px 8px rgba(0,0,0,0.8); position: relative; z-index: 2; animation: textGlow 0.5s infinite alternate;">🚨 紧急预警 🚨</h1>
                <p style="font-size: 32px; margin: 0 0 35px 0; font-weight: bold; position: relative; z-index: 2; animation: textPulse 0.4s infinite alternate;">发现未签收信息！</p>
                <p style="font-size: 24px; margin: 0 0 35px 0; position: relative; z-index: 2;">请立即处理相关业务</p>
                <div style="display: flex; gap: 25px; justify-content: center; position: relative; z-index: 2;">
                    <button id="closeAlert" style="
                        background: linear-gradient(135deg, #fff 0%, #f0f0f0 100%);
                        color: #ff4444;
                        border: 3px solid #ff4444;
                        padding: 18px 35px;
                        font-size: 20px;
                        border-radius: 15px;
                        cursor: pointer;
                        font-weight: bold;
                        transition: all 0.3s;
                        text-transform: uppercase;
                        letter-spacing: 1px;
                    ">我知道了</button>
                    <button id="snoozeAlert" style="
                        background: linear-gradient(135deg, #fff3cd 0%, #ffeaa7 100%);
                        color: #856404;
                        border: 3px solid #856404;
                        padding: 18px 35px;
                        font-size: 20px;
                        border-radius: 15px;
                        cursor: pointer;
                        font-weight: bold;
                        transition: all 0.3s;
                        text-transform: uppercase;
                        letter-spacing: 1px;
                    ">延迟5分钟</button>
                </div>
            `;

      modal.appendChild(content);
      document.body.appendChild(modal);

      // 添加终极CSS动画
      const style = document.createElement('style');
      style.textContent = `
                @keyframes screenPulse {
                    0% {
                        background: rgba(255, 0, 0, 0.98);
                        backdrop-filter: blur(10px);
                    }
                    100% {
                        background: rgba(255, 20, 20, 0.98);
                        backdrop-filter: blur(15px);
                    }
                }
                @keyframes emergencyAlert {
                    0% {
                        transform: scale(1) rotate(0deg);
                        box-shadow: 0 30px 80px rgba(255,0,0,0.8);
                    }
                    100% {
                        transform: scale(1.03) rotate(1deg);
                        box-shadow: 0 40px 100px rgba(255,0,0,1);
                    }
                }
                @keyframes backgroundFlash {
                    0% { opacity: 0.2; }
                    25% { opacity: 0.5; }
                    50% { opacity: 0.8; }
                    75% { opacity: 0.5; }
                    100% { opacity: 0.2; }
                }
                @keyframes textGlow {
                    0% {
                        text-shadow: 4px 4px 8px rgba(0,0,0,0.8);
                        filter: brightness(1);
                    }
                    100% {
                        text-shadow: 4px 4px 12px rgba(255,255,255,0.5);
                        filter: brightness(1.2);
                    }
                }
                @keyframes textPulse {
                    0% {
                        transform: scale(1);
                        opacity: 1;
                    }
                    100% {
                        transform: scale(1.1);
                        opacity: 0.9;
                    }
                }
                #closeAlert:hover {
                    background: linear-gradient(135deg, #ff4444 0%, #cc0000 100%) !important;
                    color: white !important;
                    transform: scale(1.2) !important;
                    box-shadow: 0 10px 20px rgba(255,68,68,0.5) !important;
                }
                #snoozeAlert:hover {
                    background: linear-gradient(135deg, #856404 0%, #654004 100%) !important;
                    color: white !important;
                    transform: scale(1.2) !important;
                    box-shadow: 0 10px 20px rgba(133,100,4,0.5) !important;
                }
            `;
      document.head.appendChild(style);

      // 绑定关闭事件
      document.getElementById('closeAlert').addEventListener('click', () => {
        document.body.removeChild(modal);
      });

      // 绑定延迟事件
      document.getElementById('snoozeAlert').addEventListener('click', () => {
        document.body.removeChild(modal);
        // 延迟5分钟后再次提醒
        setTimeout(() => {
          showAlertDialog();
        }, 5 * 60 * 1000);
      });

      // 防止ESC键关闭
      document.addEventListener(
        'keydown',
        function preventClose (e) {
          if (e.key === 'Escape' && document.getElementById('alertModal')) {
            e.preventDefault();
            e.stopPropagation();
            console.log('ESC键被禁用，弹窗无法关闭');
          }
        },
        true
      );

      // 防止点击遮罩关闭
      modal.addEventListener(
        'click',
        function preventClose (e) {
          if (e.target === modal) {
            e.preventDefault();
            e.stopPropagation();
            console.log('点击遮罩无法关闭弹窗');
          }
        },
        true
      );

      // 自动关闭（90秒后）
      setTimeout(() => {
        const modalToRemove = document.getElementById('alertModal');
        if (modalToRemove) {
          document.body.removeChild(modalToRemove);
        }
      }, 90000);
    } catch (error) {
      console.log('弹窗创建失败:', error);
    }
  }

  // 创建页面标题闪烁效果（增强版）
  function flashTitle () {
    let flashCount = 0;
    const originalTitle = document.title;

    // 创建多个不同的紧急提示标题
    const alertTitles = [
      '🚨 紧急预警 - 未签收信息 🚨',
      '⚠️ 重要提醒 - 请立即处理 ⚠️',
      '🔥 紧急事件 - 需要处理 🔥',
      '💥 重要通知 - 未签收信息 💥',
      '🚨 系统提醒 - 请查看页面 🚨',
    ];

    const flashInterval = setInterval(() => {
      if (flashCount % 2 === 0) {
        // 随机选择一个紧急标题
        const randomTitle = alertTitles[Math.floor(Math.random() * alertTitles.length)];
        document.title = randomTitle;

        // 同时尝试强制窗口关注
        if (!isWindowFocused && 'requestAttention' in window) {
          window.requestAttention();
        }
      } else {
        document.title = originalTitle;
      }
      flashCount++;

      if (flashCount > 60) {
        // 闪烁30次后停止（30秒）
        clearInterval(flashInterval);
        document.title = originalTitle;
      }
    }, 400); // 每400ms闪烁一次，更频繁

    // 同时在控制台输出紧急信息
    console.log('🚨 紧急提醒：发现未签收信息，请立即处理！');
    console.log('📍 原始页面标题：', originalTitle);

    // 如果窗口未聚焦，启动超强提醒机制
    if (!isWindowFocused) {
      setTimeout(() => {
        if (!isWindowFocused) {
          console.log('⚠️ 未签收信息：窗口仍未聚焦，启动超强提醒机制');
          triggerMinimizedAlert();
        }
      }, 5000); // 5秒后检查
    }
  }

  // 掉线状态专用标题闪烁（超强版）
  function flashTitleForStatus (message) {
    let flashCount = 0;
    const originalTitle = document.title;

    // 掉线状态的标题（更多变化）
    const statusTitles = [
      '🚨 平台掉线 - 请重新登录 🚨',
      '⚠️ 系统异常 - 需要处理 ⚠️',
      '🔥 连接中断 - 紧急提醒 🔥',
      '💥 掉线警告 - 请查看 💥',
      '🚨 登录失效 - 系统异常 🚨',
      '⚡ 网络错误 - 请检查连接 ⚡',
      '🔴 服务器断开 - 重新连接 🔴',
      '🔔 重要通知 - 系统掉线 🔔',
      '⚠️ 连接失败 - 请重新登录 ⚠️',
      '🚨 紧急提醒 - 平台异常 🚨',
    ];

    // 更频繁的闪烁
    const flashInterval = setInterval(() => {
      if (flashCount % 2 === 0) {
        // 随机选择一个掉线状态标题
        const randomTitle = statusTitles[Math.floor(Math.random() * statusTitles.length)];
        document.title = randomTitle;

        // 同时尝试强制窗口关注
        if (!isWindowFocused && 'requestAttention' in window) {
          window.requestAttention();
        }
      } else {
        document.title = originalTitle;
      }
      flashCount++;

      // 延长闪烁时间到30秒（60次）
      if (flashCount > 60) {
        clearInterval(flashInterval);
        document.title = originalTitle;
      }
    }, 400); // 每400ms闪烁一次，更频繁

    // 同时在控制台输出掉线信息
    console.log('🚨 掉线提醒：' + message);
    console.log('📍 原始页面标题：', originalTitle);
    console.log('🔄 开始超强标题闪烁（30秒）');

    // 额外：如果窗口仍然未聚焦，启动额外的提醒机制
    setTimeout(() => {
      if (!isWindowFocused) {
        console.log('⚠️ 窗口仍未聚焦，启动额外提醒机制');
        triggerMinimizedAlert();
      }
    }, 10000); // 10秒后检查
  }

  // 创建页面闪烁效果（柔和版）
  function flashPage () {
    try {
      const body = document.body;
      let flashCount = 0;
      const originalBodyBg = body.style.backgroundColor;

      // 创建柔和的边框闪烁效果
      const borderFlash = document.createElement('div');
      borderFlash.id = 'borderFlash';
      borderFlash.style.cssText = `
                position: fixed;
                top: 0;
                left: 0;
                width: 100vw;
                height: 100vh;
                border: 4px solid transparent;
                z-index: 2147483646;
                pointer-events: none;
                box-sizing: border-box;
                animation: gentleBorderFlash 1s infinite alternate;
            `;

      // 添加柔和的动画样式
      const style = document.createElement('style');
      style.textContent = `
                @keyframes gentleBorderFlash {
                    0% {
                        border-color: rgba(255, 68, 68, 0.3);
                        background: rgba(255, 68, 68, 0.05);
                    }
                    100% {
                        border-color: rgba(255, 68, 68, 0.8);
                        background: rgba(255, 68, 68, 0.1);
                    }
                }
            `;
      document.head.appendChild(style);

      document.body.appendChild(borderFlash);

      const flashInterval = setInterval(() => {
        // 逐渐减弱闪烁效果
        const progress = flashCount / 5; // 0到1的进度（5秒）
        const opacity = 0.8 * (1 - progress); // 逐渐降低透明度
        const duration = 1 + progress * 1; // 逐渐延长动画时间

        borderFlash.style.animation = `gentleBorderFlash ${duration}s infinite alternate`;
        borderFlash.style.borderColor = `rgba(255, 68, 68, ${opacity * 0.5})`;
        borderFlash.style.background = `rgba(255, 68, 68, ${opacity * 0.05})`;

        flashCount++;

        if (flashCount > 5) {
          // 5秒后停止
          clearInterval(flashInterval);
          if (borderFlash.parentNode) {
            borderFlash.parentNode.removeChild(borderFlash);
          }
          if (style.parentNode) {
            style.parentNode.removeChild(style);
          }
          body.style.backgroundColor = originalBodyBg;
        }
      }, 1000); // 每秒更新一次
    } catch (error) {
      console.log('页面闪烁失败:', error);
    }
  }

  // 系统级紧急提醒
  function systemEmergencyAlert () {
    try {
      console.log('🚨 触发系统级紧急提醒！');

      // 1. 最大音量警报声
      const emergencyAudio = new Audio(
        'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
      );
      emergencyAudio.volume = 1.0;

      // 播放3次，每次间隔1秒
      for (let i = 0; i < 3; i++) {
        setTimeout(() => {
          emergencyAudio.play().catch(() => {
            console.log('系统音频播放失败，尝试备用方案');
          });
        }, i * 1000);
      }

      // 2. 强制页面前台显示
      if (document.hidden) {
        // 创建一个隐藏的音频元素来强制页面激活
        const forceAudio = new Audio(
          'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
        );
        forceAudio.volume = 0.1;
        forceAudio.play().catch(() => { });
      }

      // 3. 设备震动（如果支持）
      if ('vibrate' in navigator) {
        navigator.vibrate([1000, 500, 1000, 500, 1000]);
      }
    } catch (error) {
      console.error('系统级紧急提醒失败:', error);
    }
  }

  // 综合提醒函数（终极版）
  function triggerAlert () {
    const now = Date.now();

    // 防止重复提醒（3秒内）
    if (now - lastAlertTime < 3000) {
      return;
    }

    lastAlertTime = now;
    alertCount++;

    console.log(`🚨 触发第${alertCount}次终极预警: ${new Date()}`);

    // 1. 系统级紧急提醒（立即执行）
    systemEmergencyAlert();

    // 2. 播放警报声（突破静音）
    playAlertSound();

    // 3. 桌面通知
    showDesktopNotification('🚨 紧急预警 🚨', '发现未签收信息，请立即处理！');

    // 4. 弹窗提醒（增强版）
    showAlertDialog();

    // 5. 标题闪烁（增强版）
    flashTitle();

    // 6. 页面闪烁（增强版）
    flashPage();

    // 7. 延迟音频提醒
    setTimeout(() => {
      playAlertSound();
    }, 1000);

    // 8. 创建浏览器通知徽章（如果可能）
    try {
      if (navigator.setAppBadge) {
        navigator.setAppBadge(alertCount);
      }
    } catch (e) {
      console.log('浏览器徽章设置失败:', e);
    }

    // 9. 持续提醒（每8秒一次，直到用户处理）
    if (!isAlerting) {
      isAlerting = true;
      let persistentCount = 0;
      const persistentAlert = setInterval(() => {
        persistentCount++;

        if (document.getElementById('alertModal')) {
          // 如果弹窗还在，继续强化提醒
          playAlertSound();

          // 每3次强化一次提醒
          if (persistentCount % 3 === 0) {
            systemEmergencyAlert();
            showDesktopNotification(
              '🔥 持续紧急预警 🔥',
              `未签收信息仍未处理！\n已提醒${persistentCount}次\n请立即处理！`
            );
          } else {
            showDesktopNotification('持续预警', `未签收信息仍未处理\n已等待${persistentCount * 8}秒`);
          }
        } else {
          // 弹窗关闭，停止持续提醒
          clearInterval(persistentAlert);
          isAlerting = false;

          // 清除徽章
          try {
            if (navigator.clearAppBadge) {
              navigator.clearAppBadge();
            }
          } catch (e) { }
        }

        // 如果提醒超过10次（80秒），停止自动提醒
        if (persistentCount > 10) {
          clearInterval(persistentAlert);
          isAlerting = false;
          console.log('自动提醒已停止，请手动检查页面');
        }
      }, 8000);
    }
  }

  // 初始化插件
  function initPlugin () {
    console.log('开始初始化插件...');

    // 不在初始化时请求通知权限，而是在需要时请求
    // 这避免了在没有用户交互时被浏览器拒绝权限

    // 初始化音频上下文
    initAudioContext();

    // 加载单位电话号码映射
    loadUnitPhoneMap();

    // 尝试多种方式添加按钮
    addButtonsToPage();
  }

  // 添加按钮到页面
  function addButtonsToPage () {
    console.log('尝试添加按钮到页面...');

    // 等待页面完全加载后再添加按钮
    setTimeout(() => {
      // 方法1: 查找.topStab元素
      var topStabElement = document.querySelector('.topStab');
      if (topStabElement) {
        console.log('找到.topStab元素，添加按钮');
        addButtonsToElement(topStabElement);
        return;
      }

      // 方法2: 查找表单区域
      var formElement = document.querySelector('.text-c');
      if (formElement) {
        console.log('找到表单区域，添加按钮');
        addButtonsToElement(formElement);
        return;
      }

      // 方法3: 查找表格区域
      var tableElement = document.querySelector('.mt-20');
      if (tableElement) {
        console.log('找到表格区域，添加按钮');
        addButtonsToElement(tableElement);
        return;
      }

      // 方法4: 查找包含"查询"或"搜索"的元素
      var elements = document.querySelectorAll('*');
      for (var i = 0; i < elements.length; i++) {
        var element = elements[i];
        if (element.innerText && (element.innerText.includes('查询') || element.innerText.includes('搜索'))) {
          console.log('找到查询相关元素:', element);
          addButtonsToElement(element);
          return;
        }
      }

      // 方法5: 直接添加到body顶部
      console.log('未找到合适位置，添加到body顶部');
      var container = document.createElement('div');
      container.id = 'alertPluginFixedContainer';
      container.style.cssText = `
            position: fixed !important;
            top: 10px !important;
            right: 10px !important;
            z-index: 2147483647 !important;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
            padding: 15px !important;
            border: 2px solid #4CAF50 !important;
            border-radius: 10px !important;
            box-shadow: 0 4px 15px rgba(0,0,0,0.2) !important;
            color: white !important;
            font-weight: bold !important;
            display: block !important;
            visibility: visible !important;
        `;
      addButtonsToElement(container);
      document.body.appendChild(container);

      // 调试：确认按钮容器已添加
      console.log('=== 按钮容器调试信息 ===');
      console.log('按钮容器元素:', container);
      console.log('按钮容器ID:', container.id);
      console.log('按钮容器样式:', container.style.cssText);
      console.log('按钮容器位置信息:');
      console.log('  - offsetTop:', container.offsetTop);
      console.log('  - offsetLeft:', container.offsetLeft);
      console.log('  - offsetWidth:', container.offsetWidth);
      console.log('  - offsetHeight:', container.offsetHeight);
      console.log('  - computed style:', getComputedStyle(container));
      console.log('=== 调试信息结束 ===');

      // 添加位置验证
      setTimeout(() => {
        const debugContainer = document.getElementById('alertPluginFixedContainer');
        if (debugContainer) {
          console.log('按钮容器存在，位置验证:');
          console.log('  - 实际位置:', {
            top: debugContainer.offsetTop,
            left: debugContainer.offsetLeft,
            right: window.innerWidth - debugContainer.offsetLeft - debugContainer.offsetWidth,
            bottom: window.innerHeight - debugContainer.offsetTop - debugContainer.offsetHeight,
          });
          console.log('  - 样式验证:', getComputedStyle(debugContainer).position);
        } else {
          console.error('❌ 按钮容器不存在！');
        }
      }, 3000);
    }, 2000); // 等待2秒让页面完全加载
  }

  // 向指定元素添加按钮
  function addButtonsToElement (element) {
    console.log('正在向元素添加按钮:', element);
    console.log('元素当前HTML:', element.innerHTML);

    // 创建按钮容器，避免覆盖原有内容
    var buttonContainer = document.createElement('div');
    buttonContainer.id = 'alertPluginButtons';
    buttonContainer.style.cssText =
      'margin: 10px 0; padding: 10px; background: #f8f9fa; border: 1px solid #dee2e6; border-radius: 5px;';

    buttonContainer.innerHTML = `
            <div style="font-weight: bold; margin-bottom: 10px; color: #495057;">🚨 预警插件控制面板</div>
            <button class='btn btn-warning radius' id='playBtn' style='margin: 5px; padding: 8px 16px; font-size: 14px;'>🔊 播放警报声</button>
            <button class='btn btn-danger radius' id='testAlertBtn' style='margin: 5px; padding: 8px 16px; font-size: 14px;'>🧪 测试提醒</button>
            <button class='btn btn-info radius' id='debugBtn' style='margin: 5px; padding: 8px 16px; font-size: 14px;'>🔍 调试单位匹配</button>
        `;

    // 将按钮容器添加到元素中
    element.appendChild(buttonContainer);

    // 绑定按钮事件
    document.getElementById('playBtn').addEventListener('click', function () {
      console.log('播放按钮被点击');
      playAlertSound();
    });

    document.getElementById('testAlertBtn').addEventListener('click', function () {
      console.log('测试提醒按钮被点击');
      triggerAlert();
    });

    document.getElementById('debugBtn').addEventListener('click', function () {
      console.log('调试单位匹配按钮被点击');
      debugUnitMatching();
      // 重新更新显示以查看匹配结果
      setTimeout(() => {
        updateUnitPhoneDisplay();
      }, 1000);
    });

    console.log('成功添加按钮到元素:', element);
    console.log('按钮容器:', buttonContainer);

    // 强制显示按钮
    buttonContainer.style.display = 'block !important';
    buttonContainer.style.visibility = 'visible !important';
    buttonContainer.style.opacity = '1 !important';
  }

  // 监控函数
  function startMonitoring () {
    setInterval(function () {
      console.log('Start Search：' + new Date());

      // 检查是否存在setTodayXf和search函数，如果不存在则跳过
      if (typeof window.setTodayXf === 'function') {
        window.setTodayXf();
      }
      if (typeof window.search === 'function') {
        window.search();
      }

      setTimeout(function () {
        var table = document.getElementById('DataTables_Table_0');
        if (table && table.rows && table.rows.length > 1) {
          let hasUnsignedInfo = false;

          // 遍历所有数据行，检查是否有未签收信息
          for (let i = 1; i < table.rows.length; i++) {
            const row = table.rows[i];
            if (row.cells && row.cells.length >= 13) {
              // 确保有足够的列

              // 检查状态列（第1列，索引0）和签收时间列（第12列，索引11）
              const statusCell = row.cells[0]; // 状态列
              const signTimeCell = row.cells[11]; // 签收时间列（分钟）
              const feedbackStatusCell = row.cells[12]; // 反馈状态列

              if (statusCell && signTimeCell && feedbackStatusCell) {
                const statusText = statusCell.innerText.trim();
                const signTimeText = signTimeCell.innerText.trim();
                const feedbackStatusText = feedbackStatusCell.innerText.trim();

                console.log(
                  `第${i}行 - 状态: "${statusText}", 签收时间: "${signTimeText}", 反馈状态: "${feedbackStatusText}"`
                );

                // 检查是否为未签收状态
                // 状态为空或者显示"未签收"，且签收时间为空
                const isUnsigned =
                  statusText === '' ||
                  statusText === '未签收' ||
                  statusText.includes('未签收') ||
                  signTimeText === '' ||
                  signTimeText === '0' ||
                  signTimeText === '-';

                if (isUnsigned) {
                  console.log(`发现未签收信息在第${i}行`);
                  hasUnsignedInfo = true;
                  break; // 找到一个就触发提醒
                }
              }
            }
          }

          if (hasUnsignedInfo) {
            // 触发综合提醒
            triggerAlert();
          }

          // 更新处理单位列的电话号码显示
          updateUnitPhoneDisplay();
        }
      }, 1000);
    }, 1000 * 60 * Math.round(Math.random() * 1 + 1));
  }

  // 窗口和网络状态监控
  let isWindowFocused = true;
  let focusCheckInterval = null;
  let networkCheckInterval = null;
  let loginCheckInterval = null;
  let lastNetworkStatus = navigator.onLine;
  let isLoggedIn = true;

  // 监控窗口焦点状态
  function startWindowFocusMonitor () {
    // 监听窗口焦点事件
    window.addEventListener('focus', () => {
      isWindowFocused = true;
      console.log('窗口获得焦点');
    });

    window.addEventListener('blur', () => {
      isWindowFocused = false;
      console.log('窗口失去焦点');
    });

    // 监听页面可见性变化（最小化、切换标签页等）
    document.addEventListener('visibilitychange', () => {
      if (document.hidden) {
        console.log('页面不可见（最小化或切换到其他标签页）');
        isWindowFocused = false;
      } else {
        console.log('页面重新可见');
        isWindowFocused = true;
      }
    });

    // 增强焦点检测 - 使用更可靠的方法
    function checkWindowFocus () {
      // 方法1: 使用document.hasFocus()
      const hasFocus = document.hasFocus();

      // 方法2: 使用visibilityState
      const isVisible = document.visibilityState === 'visible';

      // 方法3: 检查窗口是否在后台
      const isActive = !document.hidden;

      // 综合判断
      const shouldBeFocused = hasFocus && isVisible && isActive;

      if (isWindowFocused !== shouldBeFocused) {
        isWindowFocused = shouldBeFocused;
        console.log(
          `焦点状态更新: ${shouldBeFocused ? '获得焦点' : '失去焦点'
          } (hasFocus: ${hasFocus}, isVisible: ${isVisible}, isActive: ${isActive})`
        );
      }
    }

    // 定期检查焦点状态
    setInterval(checkWindowFocus, 2000); // 每2秒检查一次

    // 定期检查并强制前台显示（10分钟内检查10次以内）
    focusCheckInterval = setInterval(() => {
      if (!isWindowFocused && document.getElementById('alertModal')) {
        console.log('检测到窗口未聚焦但有紧急提醒，尝试强制前台显示');

        // 尝试请求用户注意
        if ('requestAttention' in window) {
          window.requestAttention();
        }

        // 创建临时音频来吸引注意
        try {
          const attentionAudio = new Audio(
            'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
          );
          attentionAudio.volume = 0.3;
          attentionAudio.play().catch(() => { });
        } catch (e) { }

        // 闪烁页面标题
        const originalTitle = document.title;
        let flashCount = 0;
        const flashInterval = setInterval(() => {
          document.title = flashCount % 2 === 0 ? '🚨 紧急提醒 - 请查看！ 🚨' : originalTitle;
          flashCount++;

          if (flashCount > 10) {
            // 5秒后停止
            clearInterval(flashInterval);
            document.title = originalTitle;
          }
        }, 500);
      }
    }, 60000); // 每60秒检查一次（10分钟内10次）
  }

  // 网络连接状态监测
  function startNetworkMonitor () {
    // 监听网络状态变化
    window.addEventListener('online', () => {
      console.log('网络已连接');
      if (!lastNetworkStatus) {
        console.log('网络从离线恢复到在线');
        showNetworkStatusNotification('网络已恢复', 'success');
      }
      lastNetworkStatus = true;
    });

    window.addEventListener('offline', () => {
      console.log('网络已断开');
      lastNetworkStatus = false;
      showNetworkStatusNotification('网络已断开！', 'error');
    });

    // 定期检查网络状态
    networkCheckInterval = setInterval(() => {
      if (!navigator.onLine) {
        console.log('检测到网络离线');
        showNetworkStatusNotification('网络连接异常！', 'error');
      }
    }, 60000); // 每60秒检查一次
  }

  // 登录状态监测（网站掉线检测）- 基于错误弹窗
  function startLoginMonitor () {
    loginCheckInterval = setInterval(() => {
      // 检测平台掉线错误弹窗（通用的invalid错误检测）
      const pageText = document.body.textContent;
      const lowerPageText = pageText.toLowerCase();

      // 检测各种包含"invalid"的错误信息
      const hasInvalidError =
        lowerPageText.includes('invalid') &&
        (lowerPageText.includes('respond') ||
          lowerPageText.includes('response') ||
          lowerPageText.includes('data') ||
          lowerPageText.includes('table') ||
          lowerPageText.includes('request') ||
          lowerPageText.includes('connection') ||
          lowerPageText.includes('session') ||
          lowerPageText.includes('timeout'));

      // 检测其他常见的错误关键词
      const hasErrorKeywords =
        lowerPageText.includes('error') ||
        lowerPageText.includes('fail') ||
        lowerPageText.includes('exception') ||
        lowerPageText.includes('timeout') ||
        lowerPageText.includes('connection') ||
        lowerPageText.includes('网络错误') ||
        lowerPageText.includes('连接失败') ||
        lowerPageText.includes('请求失败');

      // 同时检测其他可能的掉线特征
      const hasNotLoginText =
        pageText.includes('你可能尚未登录') ||
        pageText.includes('尚未登录') ||
        pageText.includes('请登录') ||
        pageText.includes('需要登录');

      // 检查URL是否跳转到登录页面
      const url = window.location.href.toLowerCase();
      const hasLoginPageUrl = url.includes('logina.jsp') || url.includes('login.jsp');

      // 综合判断掉线状态
      if (hasInvalidError || hasErrorKeywords || hasNotLoginText || hasLoginPageUrl) {
        // 检测到掉线特征
        if (isLoggedIn) {
          console.log('🚨 检测到平台掉线！');
          console.log('🔍 掉线检测结果：');
          console.log('  - Invalid错误弹窗:', hasInvalidError);
          console.log('  - 通用错误关键词:', hasErrorKeywords);
          console.log('  - 未登录提示文本:', hasNotLoginText);
          console.log('  - 登录页面URL:', hasLoginPageUrl);

          // 显示检测到的错误信息
          if (hasInvalidError) {
            const invalidMatch = pageText.match(
              /.*?invalid.*?(?:respond|response|data|table|request|connection|session|timeout).*?/i
            );
            if (invalidMatch) {
              console.log('  - 检测到的Invalid错误:', invalidMatch[0]);
            }
          }

          console.log('  - 页面文本预览:', pageText.substring(0, 300) + '...');

          isLoggedIn = false;

          // 掉线时响铃提醒（增强版）
          playLogoutAlarm();

          // 显示掉线通知
          let errorMessage = '平台已掉线！';
          if (hasInvalidError) {
            errorMessage += '检测到Invalid错误！';
          } else if (hasErrorKeywords) {
            errorMessage += '检测到系统错误！';
          } else {
            errorMessage += '检测到登录异常！';
          }

          showLoginStatusNotification(errorMessage, 'error');
        }
      } else {
        // 没有检测到掉线特征，认为正常
        isLoggedIn = true;
        console.log('✅ 平台状态正常');
      }
    }, 30000); // 每30秒检查一次（更频繁的检测）
  }

  // 显示网络/登录状态通知
  function showNetworkStatusNotification (message, type) {
    const notification = document.createElement('div');
    notification.id = 'status-notification';
    notification.style.cssText = `
            position: fixed;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            z-index: 2147483647;
            background: ${type === 'error' ? '#ff4444' : '#4CAF50'};
            color: white;
            padding: 30px 40px;
            border-radius: 15px;
            box-shadow: 0 10px 40px rgba(0,0,0,0.3);
            text-align: center;
            font-size: 18px;
            font-weight: bold;
            animation: statusAlert 0.5s infinite alternate;
        `;

    notification.innerHTML = `
            <div style="margin-bottom: 15px;">⚠️ 系统状态提醒</div>
            <div>${message}</div>
            <div style="margin-top: 15px; font-size: 14px; opacity: 0.9;">
                请检查网络连接或重新登录
            </div>
        `;

    document.body.appendChild(notification);

    // 添加CSS动画
    const style = document.createElement('style');
    style.textContent = `
            @keyframes statusAlert {
                0% { transform: translate(-50%, -50%) scale(1); }
                100% { transform: translate(-50%, -50%) scale(1.05); }
            }
        `;
    document.head.appendChild(style);

    // 播放警报声（只在错误时）
    if (type === 'error') {
      try {
        const alertSound = new Audio(
          'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
        );
        alertSound.volume = 0.6;
        alertSound.play().catch(() => { });
      } catch (e) { }
    }

    // 触发页面标题闪烁（只在错误时）
    if (type === 'error') {
      flashTitleForStatus(message);
    }

    // 触发窗口焦点监控（只在错误时且窗口未聚焦）
    if (type === 'error' && !isWindowFocused) {
      triggerMinimizedAlert();
    }

    // 自动移除时间（错误15秒，成功8秒）
    const removeTime = type === 'error' ? 15000 : 8000;
    setTimeout(() => {
      if (notification.parentNode) {
        notification.remove();
      }
    }, removeTime);
  }

  // 最小化窗口时的增强提醒（超强版）
  function triggerMinimizedAlert () {
    try {
      console.log('🔍 检测到窗口未聚焦，启动超强最小化增强提醒');

      // 1. 强制请求用户注意（多种方法）
      forceWindowAttention();

      // 2. 播放超强音频提醒
      playPersistentAudioAlert();

      // 3. 设备震动（如果支持）
      triggerDeviceVibration();

      // 4. 创建强制性页面覆盖层
      createPersistentOverlay();

      // 5. 持续的系统级提醒
      startPersistentSystemReminders();

      console.log('🎯 超强最小化增强提醒已启动');
    } catch (error) {
      console.error('最小化提醒失败:', error);
    }
  }

  // 强制请求用户注意（多种方法）
  function forceWindowAttention () {
    console.log('🔥 强制请求用户注意');

    // 方法1: requestAttention (如果支持)
    if ('requestAttention' in window) {
      try {
        window.requestAttention();
        console.log('✅ 已请求系统关注 (requestAttention)');
      } catch (e) {
        console.log('❌ requestAttention失败:', e);
      }
    }

    // 方法2: 尝试聚焦窗口
    try {
      window.focus();
      console.log('✅ 尝试聚焦窗口');
    } catch (e) {
      console.log('❌ 窗口聚焦失败:', e);
    }

    // 方法3: 模拟用户交互来吸引注意
    try {
      // 创建一个临时的输入框并聚焦
      const tempInput = document.createElement('input');
      tempInput.style.position = 'fixed';
      tempInput.style.left = '-9999px';
      document.body.appendChild(tempInput);
      tempInput.focus();
      setTimeout(() => {
        if (tempInput.parentNode) {
          tempInput.parentNode.removeChild(tempInput);
        }
      }, 100);
      console.log('✅ 模拟用户交互');
    } catch (e) {
      console.log('❌ 模拟交互失败:', e);
    }
  }

  // 播放持续音频提醒
  function playPersistentAudioAlert () {
    console.log('🔊 播放持续音频提醒');

    try {
      const attentionAudio = new Audio(
        'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
      );
      attentionAudio.volume = 0.5;

      // 播放5次，每次间隔2秒
      for (let i = 0; i < 5; i++) {
        setTimeout(() => {
          if (!isWindowFocused) {
            attentionAudio.play().catch((error) => {
              console.log(`音频播放失败 (第${i + 1}次):`, error);
            });
          }
        }, i * 2000);
      }
    } catch (e) {
      console.log('❌ 音频提醒出错:', e);
    }
  }

  // 触发设备震动
  function triggerDeviceVibration () {
    if ('vibrate' in navigator && !isWindowFocused) {
      try {
        // 更强烈的震动模式
        navigator.vibrate([1000, 500, 1000, 500, 1000]);
        console.log('📳 触发设备震动提醒');
      } catch (e) {
        console.log('❌ 震动提醒失败:', e);
      }
    }
  }

  // 创建持续的页面覆盖层
  function createPersistentOverlay () {
    const overlay = document.createElement('div');
    overlay.id = 'minimized-overlay';
    overlay.style.cssText = `
            position: fixed;
            top: 0;
            left: 0;
            width: 100vw;
            height: 100vh;
            background: rgba(255, 68, 68, 0.15);
            z-index: 2147483645;
            pointer-events: none;
            border: 5px solid rgba(255, 68, 68, 0.8);
            animation: urgentBorder 0.5s infinite alternate;
            backdrop-filter: blur(2px);
        `;

    // 添加闪烁文字
    overlay.innerHTML = `
            <div style="
                position: absolute;
                top: 50%;
                left: 50%;
                transform: translate(-50%, -50%);
                color: #ff4444;
                font-size: 24px;
                font-weight: bold;
                text-align: center;
                text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
                animation: urgentText 1s infinite alternate;
            ">
                🚨 紧急提醒！<br>请立即查看！
            </div>
        `;

    const style = document.createElement('style');
    style.textContent = `
            @keyframes urgentBorder {
                0% {
                    border-color: rgba(255, 68, 68, 0.8);
                    background: rgba(255, 68, 68, 0.15);
                    transform: scale(1);
                }
                100% {
                    border-color: rgba(255, 255, 255, 0.9);
                    background: rgba(255, 68, 68, 0.25);
                    transform: scale(1.02);
                }
            }
            @keyframes urgentText {
                0% { opacity: 0.8; transform: translate(-50%, -50%) scale(1); }
                100% { opacity: 1; transform: translate(-50%, -50%) scale(1.1); }
            }
        `;

    document.head.appendChild(style);
    document.body.appendChild(overlay);

    // 15秒后移除覆盖层
    setTimeout(() => {
      if (overlay.parentNode) {
        overlay.parentNode.removeChild(overlay);
      }
      if (style.parentNode) {
        style.parentNode.removeChild(style);
      }
    }, 15000);

    console.log('✅ 已创建持续页面覆盖层');
  }

  // 持续的系统级提醒
  function startPersistentSystemReminders () {
    const reminderInterval = setInterval(() => {
      if (!isWindowFocused) {
        // 每5秒重复一次系统级提醒
        try {
          if ('requestAttention' in window) {
            window.requestAttention();
          }

          // 尝试再次聚焦窗口
          window.focus();

          // 播放短促的提醒音
          const quickAudio = new Audio(
            'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
          );
          quickAudio.volume = 0.3;
          quickAudio.play().catch(() => { });

          console.log('🔄 持续系统级提醒');
        } catch (e) {
          console.log('❌ 持续提醒失败:', e);
        }
      } else {
        // 如果窗口已聚焦，停止持续提醒
        clearInterval(reminderInterval);
        console.log('✅ 窗口已聚焦，停止持续提醒');
      }
    }, 5000); // 每5秒检查一次

    // 2分钟后自动停止持续提醒
    setTimeout(() => {
      clearInterval(reminderInterval);
      console.log('⏰ 持续提醒超时，自动停止');
    }, 120000);
  }

  // 掉线响铃提醒
  function playLogoutAlarm () {
    console.log('🔊 播放掉线响铃提醒');

    try {
      // 使用Web Audio API创建紧急警报声
      if (audioContext && audioContext.state === 'running') {
        const alarmDuration = 3; // 3秒
        const startTime = audioContext.currentTime;

        // 创建主警报音调
        const mainOscillator = audioContext.createOscillator();
        const mainGain = audioContext.createGain();

        mainOscillator.connect(mainGain);
        mainGain.connect(audioContext.destination);

        // 设置警报音调（高频警报声）
        mainOscillator.frequency.setValueAtTime(1200, startTime);
        mainOscillator.type = 'sawtooth';

        // 音量包络
        mainGain.gain.setValueAtTime(0, startTime);
        mainGain.gain.linearRampToValueAtTime(0.4, startTime + 0.01);
        mainGain.gain.exponentialRampToValueAtTime(0.1, startTime + alarmDuration);

        // 创建频率变化（警笛效果）
        mainOscillator.frequency.setValueAtTime(1200, startTime);
        mainOscillator.frequency.linearRampToValueAtTime(800, startTime + 0.5);
        mainOscillator.frequency.linearRampToValueAtTime(1200, startTime + 1.0);
        mainOscillator.frequency.linearRampToValueAtTime(800, startTime + 1.5);
        mainOscillator.frequency.linearRampToValueAtTime(1200, startTime + 2.0);
        mainOscillator.frequency.linearRampToValueAtTime(800, startTime + 2.5);
        mainOscillator.frequency.linearRampToValueAtTime(1200, startTime + 3.0);

        mainOscillator.start(startTime);
        mainOscillator.stop(startTime + alarmDuration);

        // 重复播放3次
        setTimeout(() => playLogoutAlarm(), 4000);
        setTimeout(() => playLogoutAlarm(), 8000);

        console.log('✅ Web Audio API掉线警报声已播放');
      } else {
        // 备选方案：使用HTML5 Audio
        const alarmAudio = new Audio(
          'data:audio/wav;base64,UklGRnoGAABXQVZFZm10IBAAAAABAAEAQB8AAEAfAAABAAgAZGF0YQoGAACBhYqFbF1fdJivrJBhNjVgodDbq2EcBj+a3/L1bJiwx1DUoNbxF6q7FVU5QChWTlRTcFP1XWCcE9uBhNGi8jK4O9f7gA'
        );
        alarmAudio.volume = 0.8;

        // 播放3次，每次间隔2秒
        alarmAudio
          .play()
          .then(() => {
            console.log('✅ HTML5 Audio掉线警报声已播放');
            setTimeout(() => alarmAudio.play(), 2000);
            setTimeout(() => alarmAudio.play(), 4000);
          })
          .catch((error) => {
            console.error('❌ 掉线警报声播放失败:', error);
          });
      }

      // 同时震动提醒（如果支持）
      if ('vibrate' in navigator) {
        navigator.vibrate([500, 200, 500, 200, 500]);
      }
    } catch (error) {
      console.error('❌ 掉线响铃功能出错:', error);
    }
  }

  // 显示登录状态通知
  function showLoginStatusNotification (message, type) {
    showNetworkStatusNotification(message, type);
  }

  // 停止所有监控
  function stopAllMonitors () {
    stopWindowFocusMonitor();
    if (networkCheckInterval) {
      clearInterval(networkCheckInterval);
      networkCheckInterval = null;
    }
    if (loginCheckInterval) {
      clearInterval(loginCheckInterval);
      loginCheckInterval = null;
    }
  }

  // 等待页面加载完成后初始化
  waitForJQuery(function () {
    // 等待DataTables加载
    waitForDataTable(function () {
      initPlugin();
      startMonitoring();
      startWindowFocusMonitor();
      startNetworkMonitor();
      startLoginMonitor();

      // 初始化完成后立即更新一次电话号码显示
      setTimeout(() => {
        updateUnitPhoneDisplay();
      }, 2000);

      console.log('🚀 所有监控功能已启动：');
      console.log('  ✅ 窗口焦点监控');
      console.log('  ✅ 网络连接监控');
      console.log('  ✅ 登录状态监控');
      console.log('  ✅ 电话号码显示监控');
    });
  });
})();
